package com.xuecheng.media.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.j256.simplemagic.ContentInfo;
import com.j256.simplemagic.ContentInfoUtil;
import com.sun.org.apache.xerces.internal.impl.xpath.XPath;
import com.xuecheng.base.exception.XueChengPlusException;
import com.xuecheng.base.model.PageParams;
import com.xuecheng.base.model.PageResult;
import com.xuecheng.base.model.RestResponse;
import com.xuecheng.media.mapper.MediaFilesMapper;
import com.xuecheng.media.mapper.MediaProcessMapper;
import com.xuecheng.media.model.dto.QueryMediaParamsDto;
import com.xuecheng.media.model.dto.UploadFileParamsDto;
import com.xuecheng.media.model.dto.UploadFileResultDto;
import com.xuecheng.media.model.po.MediaFiles;
import com.xuecheng.media.model.po.MediaProcess;
import com.xuecheng.media.service.MediaFileService;
import io.minio.*;
import io.minio.errors.*;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import lombok.extern.slf4j.Slf4j;
import lombok.val;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author Mr.M
 * @version 1.0
 * @description TODO
 * @date 2022/9/10 8:58
 */
@Slf4j
@Service
public class MediaFileServiceImpl implements MediaFileService {


    @Autowired
    MediaFileService currentProxy;

    @Autowired
    MediaFilesMapper mediaFilesMapper;

    @Autowired
    MediaProcessMapper mediaProcessMapper;

    @Autowired
    MinioClient minioClient;

    //存储普通文件
    @Value("${minio.bucket.files}")
    private String bucket_mediafiles;

    //存储视频
    @Value("${minio.bucket.videofiles}")
    private String bucket_video;

    @Override
    public PageResult<MediaFiles> queryMediaFiels(Long companyId, PageParams pageParams, QueryMediaParamsDto queryMediaParamsDto) {

        //构建查询条件对象
        LambdaQueryWrapper<MediaFiles> queryWrapper = new LambdaQueryWrapper<>();

        //分页对象
        Page<MediaFiles> page = new Page<>(pageParams.getPageNo(), pageParams.getPageSize());
        // 查询数据内容获得结果
        Page<MediaFiles> pageResult = mediaFilesMapper.selectPage(page, queryWrapper);
        // 获取数据列表
        List<MediaFiles> list = pageResult.getRecords();
        // 获取数据总数
        long total = pageResult.getTotal();
        // 构建结果集
        PageResult<MediaFiles> mediaListResult = new PageResult<>(list, total, pageParams.getPageNo(), pageParams.getPageSize());
        return mediaListResult;

    }

    /**根据扩展名获取mimeType
     * @param extension 扩展名
     * @return mimeType
     */
    private String getMimeType(String extension){
       if(extension == null){
           extension="";
       }
       ContentInfo extensionMatch = ContentInfoUtil.findExtensionMatch(extension);
       String mimeType = MediaType.APPLICATION_OCTET_STREAM_VALUE;
       if(extensionMatch!=null){
           mimeType = extensionMatch.getMimeType();
       }
       return mimeType;
    }



    /**
     * 将文件上传到minio
     * @param localFilePath 文件本地路径
     * @param bucket 桶
     * @param objectName 对象名
     * @return
     */
    @Override
    public boolean addMediaFilesToMinIO( String localFilePath,String bucket, String mimeType,String objectName){
        try {
            UploadObjectArgs uploadObjectArgs = UploadObjectArgs.builder()
                    .bucket(bucket)//桶
                    .contentType(mimeType)
                    .filename(localFilePath)//指定本地文件路径
                    .object(objectName)//对象名 放在子目录下
//                    .contentType(mimeType)//设置媒体文件类型
                    .build();//
            //上传文件
            minioClient.uploadObject(uploadObjectArgs);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            log.error("上传文件出错,bucket:{},objectName:{},错误信息:{}",bucket,objectName,e.getMessage());
        }
        return false;
    }

    //获取文件默认存储目录路径 年/月/日
    private String getDefaultFolderPath() {
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
       String folder = sdf.format(new Date()).replace("-","/")+"/";
       return folder;
    }
//    /**
//     * 文件上传
//     */
//    @Override
//    public UploadFileResultDto uploadFile(Long companyId, UploadFileParamsDto uploadFileParamsDto, String localFilePath,String ojectName){
//        return null;
//    }
    /**
     * 文件上传
     * @param companyId 机构Id
     * @param uploadFileParamsDto 文件的信息
     * @param localFilePath 本地路径
     * @param objectName  如果传入objectname 要按照objectname的目录去存储，如果不传就按 年月日  目录存储
     * @return UploadFileResultDto
    */
    @Override
    public UploadFileResultDto uploadFile(Long companyId, UploadFileParamsDto uploadFileParamsDto, String localFilePath,String objectName) {
      //先得到扩展名
      String filename = uploadFileParamsDto.getFilename();
      String extension = filename.substring(filename.lastIndexOf("."));
      String mimeType = getMimeType(extension);
      //根据文件扩展名拿到mimeType
      //将文件上传到minio
      String defaultFolderPath = getDefaultFolderPath();
      //文件的md5值
      String fileMd5 = getFileMd5(new File(localFilePath));

      if(StringUtils.isEmpty(objectName)){
          objectName = defaultFolderPath + fileMd5 + extension;
      }

      //约定一下年月日存储
      boolean result = addMediaFilesToMinIO(localFilePath,bucket_mediafiles, mimeType ,objectName);
      if(result == false){
          XueChengPlusException.cast("上传文件失败");
      }
      //入库信息
      MediaFiles mediaFiles = currentProxy.addMediaFilesToDb(companyId,fileMd5,uploadFileParamsDto,bucket_mediafiles,objectName);
      if(mediaFiles == null){
          XueChengPlusException.cast("文件上传后保存信息失败");
      }
      UploadFileResultDto uploadFileResultDto = new UploadFileResultDto();
      BeanUtils.copyProperties(mediaFiles,uploadFileResultDto);
      return uploadFileResultDto;
    }


    /**
     * @description 将文件信息添加到文件表
     * @param companyId  机构id
     * @param fileMd5  文件md5值
     * @param uploadFileParamsDto  上传文件的信息
     * @param bucket  桶
     * @param objectName 对象名称
     * @return com.xuecheng.media.model.po.MediaFiles
     * @author Mr.M
     * @date 2022/10/12 21:22
     */
    @Transactional
    public MediaFiles addMediaFilesToDb(Long companyId,String fileMd5,UploadFileParamsDto uploadFileParamsDto,String bucket,String objectName){
      //将文件信息保存到数据库
      MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
      if(mediaFiles == null){
          mediaFiles = new MediaFiles();
          BeanUtils.copyProperties(uploadFileParamsDto,mediaFiles);
          //文件id
          mediaFiles.setId(fileMd5);
          //机构id
          mediaFiles.setCompanyId(companyId);
          //桶
          mediaFiles.setBucket(bucket);
          // file_path
          mediaFiles.setFileId(objectName);
          //file_id
          mediaFiles.setFileId(fileMd5);
//          //url
//          mediaFiles.setUrl("/"+bucket+"/"+objectName);
          //写入文件路径
          mediaFiles.setFilePath(objectName);
          //上传时间
          mediaFiles.setCreateDate(LocalDateTime.now());
          //状态
          mediaFiles.setStatus("1");
          //审核状态
          mediaFiles.setAuditStatus("002003");
          //插入数据库
          int insert = mediaFilesMapper.insert(mediaFiles);
          if(insert<=0){
              log.debug("向数据库保存文件失败,objectName:{}",bucket,objectName);
              return null;
          }
          // 记录待处理任务
          // 向MediaProcess插入记录
          // 如果是avi视频才会写入待处理任务
          addWaitingTask(mediaFiles);
      }
        return mediaFiles;
    }
    /**
     * 添加待处理任务
     * @param mediaFiles 媒资文件信息
     */
    private void addWaitingTask(MediaFiles mediaFiles){
        //获取文件的mimeType
        String filename = mediaFiles.getFilename();
        String extension = filename.substring(filename.lastIndexOf("."));
        String mimeType = getMimeType(extension);
        //通过mimeType判断如果是avi视频写入待处理任务
        if(mimeType.equals("video/x-msvideo")){
            MediaProcess mediaProcess = new MediaProcess();
            BeanUtils.copyProperties(mediaFiles,mediaProcess);
            // 最主要的是一个未处理状态，是1
            mediaProcess.setStatus("1");
            mediaProcess.setCreateDate(LocalDateTime.now());
            mediaProcess.setFailCount(0);
            mediaProcessMapper.insert(mediaProcess);
        }

    }

    @Override
    public MediaFiles getFileById(String mediaId){
        return mediaFilesMapper.selectById(mediaId);
    }
    @Override
    public RestResponse<Boolean> checkFile(String fileMd5) {
        //先查询数据库
        MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
        if(mediaFiles!=null){
            //如果数据库存在再查询minio
            String bucket = mediaFiles.getBucket();
            String filePath = mediaFiles.getFilePath();
            InputStream stream = null;
            try {
                stream = minioClient.getObject(GetObjectArgs.builder()
                        .bucket(bucket)
                        .object(filePath)
                        .build());
                if(stream!=null){
                    return RestResponse.success(true);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return RestResponse.success(false);
    }

    @Override
    public RestResponse<Boolean> checkChunk(String fileMd5, int chunkIndex) {
      //分块的存储路径是：md5前两位为两个目录，chunk存储分块文件
      //根据md5得到分块文件的路径
      String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
      GetObjectArgs getObjectArgs = GetObjectArgs.builder()
              .bucket(bucket_video)
              .object(chunkFileFolderPath+chunkIndex)
              .build();

        try {
            InputStream stream = minioClient.getObject(getObjectArgs);
            if(stream!= null){
                return RestResponse.success(true);
            }
        } catch (Exception e) {

        }

        return RestResponse.success(false);
    }

    //得到分块文件的目录
    private String getChunkFileFolderPath(String fileMd5) {
        return fileMd5.substring(0, 1) + "/" + fileMd5.substring(1, 2) + "/" + fileMd5 + "/" + "chunk" + "/";
    }

    @Override
    public RestResponse uploadChunk(String fileMd5, int chunk, String  bytes) {
        //分块文件的路径
        String chunkFilePath = getChunkFileFolderPath(fileMd5) + chunk;
        //获取mimeType
        String mimeType = getMimeType(null);
        //将分块文件上传到minio
        try {
            addMediaFilesToMinIO(bytes,  bucket_video, mimeType,chunkFilePath);
            return RestResponse.success(true);
        }catch (Exception e){
            e.printStackTrace();
            log.debug("上传分块文件:{},失败:{}",chunkFilePath,e.getMessage());
        }
            return RestResponse.validfail(false,"上传分块文件失败");
        //上传成功
    }

    /**
     * 合并分块文件
     * @param companyId
     * @param fileMd5
     * @param chunkTotal
     * @param uploadFileParamsDto
     * @return
     */
    @Override
    public RestResponse mergechunks(Long companyId, String fileMd5, int chunkTotal,
                                    UploadFileParamsDto uploadFileParamsDto) {
    //找到所有的分块文件，调用minio的sdk进行文件合并
    String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
    List<ComposeSource> sources = Stream.iterate(0,i -> ++i)
            .limit(chunkTotal)
            .map(i ->ComposeSource.builder()
                    .bucket(bucket_video)
                    .object(chunkFileFolderPath.concat(Integer.toString(i)))
                    .build())
            .collect(Collectors.toList());
    //拿到源文件名称
    String filename = uploadFileParamsDto.getFilename();
    //扩展名
    String extension = filename.substring(filename.lastIndexOf("."));
    //指定合并后的objectName等信息
    String objectName = getFilePathByMd5(fileMd5,extension);

        try {
            ObjectWriteResponse response = minioClient.composeObject(
                    ComposeObjectArgs.builder()
                            .bucket(bucket_video)
                            .object(objectName)
                            .sources(sources)
                            .build());
            log.debug("合并文件成功:{}",objectName);
        } catch (Exception e) {
            log.error("合并文件出错，bucket:{},objectName:{},错误信息:{}",bucket_video,objectName,e.getMessage());
            return RestResponse.validfail(false,"合并文件异常");
        }
        //校验合并后的和源文件是否一致
        File file = downloadFileFromMinIO(bucket_video,objectName);
        uploadFileParamsDto.setFileSize(file.length());
        if(file == null){
            log.debug("下载合并后文件失败,mergeFilePath:{}",objectName);
            return RestResponse.validfail(false, "下载合并后文件失败。");
        }

        //计算合并后文件的md5
        try(InputStream fileInputStream = new FileInputStream(file)){
            String mergeFile_md5 = DigestUtils.md5Hex(fileInputStream);
            //比较原始md5和合并后文件的md5
            if(!fileMd5.equals(mergeFile_md5)){
                log.error("校验合并文件md5值不一致,原始文件:{},合并文件:{}",fileMd5,mergeFile_md5);
                return RestResponse.validfail(false,"文件校验失败");
            }
        }catch(Exception e){
                return RestResponse.validfail(false,"文件校验失败");
        }
        //将文件信息入库
        MediaFiles mediaFiles = currentProxy.addMediaFilesToDb(companyId,fileMd5,uploadFileParamsDto,bucket_video,objectName);
        if(mediaFiles == null){
            return RestResponse.validfail(false,"文件入库失败");
        }
        //清理分块文件:找到分块文件，把它删除
       clearChunkFiles(chunkFileFolderPath,chunkTotal);

        return  RestResponse.success(true);
    }

    @Override
    public File downloadFileFromMinIO(String bucket,String objectName){
        //临时文件
        File minioFile = null;
        FileOutputStream outputStream = null;
        try{
            InputStream stream = minioClient.getObject(GetObjectArgs.builder()
                    .bucket(bucket)
                    .object(objectName)
                    .build());
            //创建临时文件
            minioFile=File.createTempFile("minio", ".merge");
            outputStream = new FileOutputStream(minioFile);
            IOUtils.copy(stream,outputStream);
            return minioFile;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

    private String getFilePathByMd5(String fileMd5,String fileExt){
        return   fileMd5.substring(0,1) + "/" + fileMd5.substring(1,2) + "/" + fileMd5 + "/" +fileMd5 +fileExt;
    }

    private void clearChunkFiles(String chunkFileFolderPath,int chunkTotal){

      Iterable<DeleteObject> objects = Stream.iterate(0,i -> ++i).limit(chunkTotal).map(i -> new DeleteObject(
              chunkFileFolderPath.concat(Integer.toString(i))
      )).collect(Collectors.toList());
      RemoveObjectsArgs removeObjectsArgs = RemoveObjectsArgs.builder().bucket(bucket_video).objects(objects).build();
      Iterable<Result<DeleteError>> results = minioClient.removeObjects(removeObjectsArgs);
      //要想真正删除，需要遍历一下
      results.forEach(f->{
          try {
              DeleteError deleteError = f.get();
          } catch (Exception e) {
              e.printStackTrace();
          }
      });
    }

    //获取文件的md5
    private String getFileMd5(File file){
        try(FileInputStream fileInputStream = new FileInputStream(file)){
           String fileMd5 = DigestUtils.md5Hex(fileInputStream);
           return fileMd5;
        }catch(Exception e){
            e.printStackTrace();
            return null;
        }
    }
}
